/**
 * user-query-utils.js
 * 用户查询工具模块
 * 
 * 功能：
 * - 根据角色、标签、状态等条件查询用户列表
 * - 支持多种格式化选项
 * - 统一姓名提取和角色文本转换逻辑
 * - 提供医生、护士、员工、患者等特定角色查询接口
 */

const db = uniCloud.database();
const _ = db.command;
const crypto = require('crypto');
const fs = require('fs');

/**
 * 角色文本映射表
 */
const ROLE_TEXT_MAP = {
	'admin': '超级管理员',
	'manager': '管理员',
	'director': '院长',
	'vice_director': '副院长',
	'doctor': '医生',
	'nurse': '护士',
	'head_nurse': '护士长',
	'finance': '财务',
	'administrative': '行政',
	'purchaser': '采购员',
	'staff': '员工',
	'patient': '患者'
};

/**
 * 提取用户显示名称
 * 优先级：realname_auth.real_name > nickname > username > mobile > _id
 */
function extractDisplayName(user) {
	if (user.realname_auth && user.realname_auth.real_name) {
		return user.realname_auth.real_name;
	}
	if (user.nickname) {
		return user.nickname;
	}
	if (user.username) {
		return user.username;
	}
	if (user.mobile) {
		return user.mobile;
	}
	return user._id || '未知';
}

/**
 * 角色优先级映射（数值越大，优先级越高）
 * 用于角色去重：当用户有多个角色时，显示优先级最高的角色
 */
const ROLE_PRIORITY = {
	'director': 100,           // 院长
	'vice_director': 90,       // 副院长
	'head_nurse': 80,          // 护士长
	'doctor': 70,              // 医生
	'finance': 60,             // 财务
	'administrative': 50,      // 行政
	'purchaser': 40,           // 采购员
	'nurse': 30,               // 护士
	'staff': 10,               // 员工
	'admin': 0,                // 管理员（系统角色，不显示）
	'manager': 0,              // 管理员（系统角色，不显示）
	'user': 0,                 // 通用角色（不显示）
	'patient': 0               // 患者（不显示）
};

/**
 * 获取用户主要角色（考虑优先级）
 * 规则：
 * 1. 排除纯系统角色：admin, manager
 * 2. 排除通用角色：user, patient
 * 3. 多个角色时，返回优先级最高的
 */
function getMainRole(user) {
	if (!user.role) return null;
	const roles = Array.isArray(user.role) ? user.role : [user.role];
	
	// 过滤出有效角色（排除系统角色和通用角色）
	const validRoles = roles.filter(r => {
		const priority = ROLE_PRIORITY[r];
		return priority !== undefined && priority > 0;
	});
	
	if (validRoles.length === 0) return null;
	
	// 返回优先级最高的角色
	let highestRole = validRoles[0];
	let highestPriority = ROLE_PRIORITY[highestRole] || 0;
	
	for (const role of validRoles) {
		const priority = ROLE_PRIORITY[role] || 0;
		if (priority > highestPriority) {
			highestPriority = priority;
			highestRole = role;
		}
	}
	
	return highestRole;
}

/**
 * 获取角色文本
 */
function getRoleText(role) {
	return ROLE_TEXT_MAP[role] || role || '';
}

/**
 * 解密函数 - 用于解密用户的实名认证信息
 * @param {String} encryptedText - 加密的文本
 * @param {String} secret - 解密密钥
 * @returns {String} 解密后的文本
 */
function decryptData(encryptedText, secret) {
	if (!encryptedText || !secret) return encryptedText;
	
	try {
		const iv = secret.slice(-16);
		const decipher = crypto.createDecipheriv('aes-256-cbc', secret, iv);
		
		const decrypted = Buffer.concat([
			decipher.update(Buffer.from(encryptedText, 'base64')),
			decipher.final()
		]);
		
		return decrypted.toString('utf-8');
	} catch (error) {
		console.error('[decryptData] 解密失败:', error);
		return encryptedText; // 解密失败时返回原始加密文本
	}
}

/**
 * 获取解密密钥
 * 从uni-id配置中获取sensitiveInfoEncryptSecret
 * @returns {String} 解密密钥
 */
async function getDecryptSecret() {
	try {
		// 优先通过路径特征判断是否为云端环境
		// 云端环境的典型路径：/tmp/function/ 或包含 @common_modules
		const isCloudEnvByPath = __dirname.includes('/tmp/function/') || __dirname.includes('@common_modules');
		
		// 通过环境变量判断
		const isCloudEnvByEnv = process.env.UNI_CLOUD_PROVIDER && process.env.UNI_CLOUD_SPACE_ID;
		
		// 尝试使用 uni-config-center 获取配置（云端和本地环境都支持）
		try {
			let createConfig;
			// 尝试多种方式引入 uni-config-center
			try {
				createConfig = require('uni-config-center');
			} catch (e1) {
				// 如果直接引入失败，尝试使用相对路径
				try {
					const path = require('path');
					const configPath = path.join(__dirname, '../../../uni_modules/uni-config-center/uniCloud/cloudfunctions/common/uni-config-center');
					createConfig = require(configPath);
				} catch (e2) {
					throw e1; // 抛出原始错误
				}
			}
			
			const config = createConfig({ pluginId: 'uni-id' });
			
			// 尝试多种方式获取配置
			let uniIdConfig = null;
			
			// 方式1：通过 requireFile 方法获取配置（类似 uni-stat 的用法）
			if (typeof config.requireFile === 'function') {
				try {
					uniIdConfig = config.requireFile('config');
				} catch (e) {
					// 如果失败，尝试其他文件名
					try {
						uniIdConfig = config.requireFile('uni-id');
					} catch (e2) {
						// 忽略错误
					}
				}
			}
			
			// 方式2：通过 _config 属性获取（uni-config-center 内部存储配置的方式）
			if (!uniIdConfig && config._config) {
				// 尝试直接访问 _config 中的配置
				if (config._config['uni-id']) {
					uniIdConfig = config._config['uni-id'];
				} else if (config._config['config']) {
					uniIdConfig = config._config['config'];
				} else {
					// 获取 _config 中的第一个配置对象
					const configKeys = Object.keys(config._config);
					if (configKeys.length > 0) {
						uniIdConfig = config._config[configKeys[0]];
					}
				}
			}
			
			// 方式3：尝试通过 config.config() 方法获取
			if (!uniIdConfig && typeof config.config === 'function') {
				try {
					uniIdConfig = config.config('uni-id');
				} catch (e) {
					// 如果失败，尝试不带参数
					try {
						uniIdConfig = config.config();
					} catch (e2) {
						// 忽略错误
					}
				}
			}
			
			// 方式4：直接访问 defaultConfig
			if (!uniIdConfig && config.defaultConfig) {
				uniIdConfig = config.defaultConfig;
			}
			
			// 尝试从配置中获取密钥
			if (uniIdConfig && uniIdConfig.sensitiveInfoEncryptSecret) {
				console.log('[getDecryptSecret] 通过 uni-config-center 成功获取密钥');
				return uniIdConfig.sensitiveInfoEncryptSecret;
			} else if (config && config.sensitiveInfoEncryptSecret) {
				// 如果 config 对象本身包含密钥
				console.log('[getDecryptSecret] 通过 uni-config-center 成功获取密钥（从 config 对象）');
				return config.sensitiveInfoEncryptSecret;
			} else {
				// 输出调试信息
				console.warn('[getDecryptSecret] uni-config-center 返回的配置中没有 sensitiveInfoEncryptSecret', {
					hasUniIdConfig: !!uniIdConfig,
					hasConfig: !!config,
					configKeys: config ? Object.keys(config) : [],
					has_config: config && config._config ? Object.keys(config._config) : [],
					uniIdConfigKeys: uniIdConfig ? Object.keys(uniIdConfig) : [],
					hasRequireFile: typeof config.requireFile === 'function'
				});
			}
		} catch (configError) {
			// uni-config-center 不可用，如果是云端环境则记录错误，本地环境继续尝试读取文件
			if (isCloudEnvByPath || isCloudEnvByEnv) {
				console.error('[getDecryptSecret] 云端配置获取失败:', configError.message || configError);
				return '';
			}
			// 本地环境继续尝试读取文件
		}
		
		// 本地环境：尝试多个可能的路径读取配置文件
		const path = require('path');
		
		// 从当前文件位置向上查找，找到项目根目录（包含 uni_modules 的目录）
		let currentDir = __dirname;
		let projectRoot = null;
		
		// 向上查找，直到找到包含 uni_modules 的目录（项目根目录）
		for (let i = 0; i < 10; i++) {
			const uniModulesPath = path.join(currentDir, 'uni_modules');
			if (fs.existsSync(uniModulesPath)) {
				projectRoot = currentDir;
				break;
			}
			const parentDir = path.dirname(currentDir);
			if (parentDir === currentDir) break; // 已到达根目录
			currentDir = parentDir;
		}
		
		// 如果找到项目根目录，构建配置文件路径
		if (projectRoot) {
			const configPath = path.join(projectRoot, 'uni_modules/uni-config-center/uniCloud/cloudfunctions/common/uni-config-center/uni-id/config.json');
			if (fs.existsSync(configPath)) {
				const localConfig = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
				return localConfig.sensitiveInfoEncryptSecret || '';
			}
		}
		
		// 如果自动查找失败，尝试几个常见的相对路径
		const possiblePaths = [
			// 路径1：从 common/dh-common 向上到项目根目录
			path.join(__dirname, '../../../../uni_modules/uni-config-center/uniCloud/cloudfunctions/common/uni-config-center/uni-id/config.json'),
			// 路径2：从 common/dh-common 向上到 cloudfunctions 目录
			path.join(__dirname, '../../../uni_modules/uni-config-center/uniCloud/cloudfunctions/common/uni-config-center/uni-id/config.json'),
			// 路径3：从 common/dh-common 到 uni-config-center (旧路径，兼容性)
			path.join(__dirname, '../../uni-config-center/uni-id/config.json')
		];
		
		// 尝试每个可能的路径
		for (const configPath of possiblePaths) {
			if (fs.existsSync(configPath)) {
				const localConfig = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
				return localConfig.sensitiveInfoEncryptSecret || '';
			}
		}
		
		// 如果所有路径都不存在，返回空字符串（不输出警告，避免云端环境误报）
		return '';
	} catch (error) {
		console.error('[getDecryptSecret] 获取解密密钥失败:', error);
		return '';
	}
}

/**
 * 解密用户实名认证信息
 * @param {Object} realnameAuth - 实名认证信息对象
 * @param {String} secret - 解密密钥
 * @returns {Object} 解密后的实名认证信息
 */
function decryptRealnameAuth(realnameAuth, secret) {
	if (!realnameAuth || !secret) return realnameAuth;
	
	try {
		const decryptedAuth = { ...realnameAuth };
		
		// 解密真实姓名
		if (realnameAuth.real_name) {
			decryptedAuth.real_name = decryptData(realnameAuth.real_name, secret);
		}
		
		// 解密身份证号
		if (realnameAuth.identity) {
			decryptedAuth.identity = decryptData(realnameAuth.identity, secret);
		}
		
		return decryptedAuth;
	} catch (error) {
		console.error('[decryptRealnameAuth] 解密实名认证信息失败:', error);
		return realnameAuth; // 解密失败时返回原始信息
	}
}

/**
 * 格式化手机号（隐藏中间4位）
 */
function formatMobile(mobile) {
	if (!mobile || mobile.length < 11) return mobile;
	return mobile.replace(/(\d{3})\d{4}(\d{4})/, '$1****$2');
}

/**
 * 根据关键词过滤用户列表（通用函数）
 * @param {Array} users - 用户列表
 * @param {String} keyword - 搜索关键词
 * @returns {Array} 过滤后的用户列表
 */
function filterUsersByKeyword(users, keyword) {
	if (!keyword || !keyword.trim()) return users;
	
	const lowerKeyword = keyword.toLowerCase().trim();
	return users.filter(user => 
		(user.realName?.toLowerCase().includes(lowerKeyword)) ||
		(user.displayName?.toLowerCase().includes(lowerKeyword)) ||
		(user.mobile?.includes(keyword))
	);
}

/**
 * 格式化用户数据
 * @param {Object} user - 用户原始数据
 * @param {String} format - 格式化类型：'default', 'with_role', 'with_mobile', 'full'
 * @param {Boolean} isPatientQuery - 是否是患者查询（用于特殊处理患者角色）
 * @param {String} decryptSecret - 解密密钥（可选）
 * @returns {Object|null} 格式化后的用户数据，如果用户无有效角色则返回 null
 */
function formatUserData(user, format = 'default', isPatientQuery = false, decryptSecret = '') {
	// 🔥 首先解密实名认证信息（如果提供了密钥）
	let decryptedRealnameAuth = null;
	if (user.realname_auth) {
		if (decryptSecret) {
			try {
				decryptedRealnameAuth = decryptRealnameAuth(user.realname_auth, decryptSecret);
				// 将解密后的实名认证信息临时合并到用户对象中，供 extractDisplayName 使用
				user = {
					...user,
					realname_auth: decryptedRealnameAuth
				};
			} catch (decryptError) {
				console.error('[formatUserData] 解密实名认证信息失败:', decryptError);
			}
		} else {
			console.warn('[formatUserData] 解密密钥为空，无法解密实名认证信息，用户ID:', user._id);
		}
	}
	
	// 基于解密后的数据提取显示名称
	const baseName = extractDisplayName(user);
	
	// 🔥 特殊处理：如果是患者查询，直接检查是否有患者角色
	let mainRole = null;
	let roleText = '';
	
	if (isPatientQuery) {
		// 患者查询场景：直接使用 patient 角色
		const roles = Array.isArray(user.role) ? user.role : [user.role];
		if (roles.includes('patient')) {
			mainRole = 'patient';
			roleText = getRoleText('patient');
		}
	} else {
		// 非患者查询场景：使用正常的角色优先级逻辑
		mainRole = getMainRole(user);
		roleText = getRoleText(mainRole);
	}
	
	// 如果用户没有有效角色（mainRole为null），返回null
	if (!mainRole && format === 'with_role') {
		return null;
	}
	
	const result = {
		_id: user._id,
		realName: baseName
	};
	
	switch (format) {
		case 'with_role':
			// 格式：张三 (医生) 或 张三 (患者)
			result.displayName = roleText ? `${baseName} (${roleText})` : baseName;
			break;
			
		case 'with_mobile':
			// 格式：张三 (138****1234)
			const mobile = formatMobile(user.mobile);
			result.displayName = mobile ? `${baseName} (${mobile})` : baseName;
			break;
			
		case 'full':
			// 完整信息
			result.displayName = roleText ? `${baseName} (${roleText})` : baseName;
			result.avatar = user.avatar || '';  // 头像地址
			result.mobile = user.mobile || '';
			result.mobile_confirmed = user.mobile_confirmed;  // 手机号认证状态
			result.mobileFormatted = formatMobile(user.mobile);
			result.email = user.email || '';  // 邮箱
			result.email_confirmed = user.email_confirmed;  // 邮箱认证状态
			result.role = user.role;
			result.roleText = roleText;
			result.username = user.username || '';
			result.nickname = user.nickname || '';
			result.gender = user.gender;  // 性别
			result.status = user.status;  // 用户状态
			result.tags = user.tags || [];  // 用户标签
			result.register_date = user.register_date;  // 注册时间
			result.last_login_date = user.last_login_date;  // 最后登录时间
			result.comment = user.comment || '';  // 备注
			
			// 处理实名认证信息（已经在函数开始处解密，这里直接使用）
			if (decryptedRealnameAuth) {
				result.realname_auth = decryptedRealnameAuth;
			} else if (user.realname_auth) {
				// 如果没有解密，保持原始信息
				result.realname_auth = user.realname_auth;
			}
			break;
			
		case 'default':
		default:
			// 仅姓名
			result.displayName = baseName;
			break;
	}
	
	return result;
}

/**
 * 检查用户是否符合角色过滤条件
 * @param {Object} user - 用户对象
 * @param {Array} includeRoles - 包含的角色
 * @param {Array} excludeRoles - 排除的角色
 * @param {Boolean} allowPatients - 是否允许患者角色（默认false，用于患者专用查询）
 */
function matchesRoleFilter(user, includeRoles, excludeRoles, allowPatients = false) {
	if (!user.role) return false;
	
	const roles = Array.isArray(user.role) ? user.role : [user.role];
	
	// 🔥 核心改进：首先检查用户是否有至少一个有效角色（优先级 > 0）
	// 如果允许患者，则患者也算有效角色
	// admin 和 manager 是系统角色，应该总是被允许（即使优先级为 0）
	const hasValidRole = roles.some(role => {
		// 系统管理员角色总是被允许
		if (role === 'admin' || role === 'manager') {
			return true;
		}
		const priority = ROLE_PRIORITY[role];
		if (allowPatients && role === 'patient') {
			return true;
		}
		return priority !== undefined && priority > 0;
	});
	
	if (!hasValidRole) {
		// 用户没有任何有效角色（都是系统角色），直接排除
		return false;
	}
	
	// 检查排除角色
	if (excludeRoles && excludeRoles.length > 0) {
		// 如果用户的所有角色都在排除列表中，则排除该用户
		const hasOnlyExcludedRoles = roles.every(role => excludeRoles.includes(role));
		if (hasOnlyExcludedRoles) return false;
	}
	
	// 检查包含角色
	if (includeRoles && includeRoles.length > 0) {
		// 用户至少有一个角色在包含列表中
		const hasIncludedRole = roles.some(role => includeRoles.includes(role));
		if (!hasIncludedRole) return false;
	}
	
	return true;
}

/**
 * 查询用户列表
 * 
 * @param {Object} options - 查询选项
 * @param {Array} options.includeRoles - 包含的角色列表（如 ['doctor', 'nurse']）
 * @param {Array} options.excludeRoles - 排除的角色列表（如 ['patient']）
 * @param {Array} options.includeTags - 包含的标签列表（如 ['vip1', 'new_user']）- 扩展功能
 * @param {Boolean} options.activeOnly - 仅查询激活用户（默认 true）
 * @param {Boolean} options.verifiedOnly - 仅查询实名认证用户（默认 false）- 扩展功能
 * @param {Boolean} options.allowPatients - 是否允许患者角色（默认 false，设为 true 时患者会被包含）
 * @param {String} options.format - 格式化类型：'default', 'with_role', 'with_mobile', 'full'（默认 'default'）
 * @param {Number} options.limit - 返回数量限制（默认 1000）
 * @param {Array} options.sortBy - 排序字段（默认按创建时间）
 * @param {Boolean} options.decryptSensitiveInfo - 是否解密敏感信息（默认 true）
 * 
 * @returns {Promise<Array>} 格式化后的用户列表
 */
async function getUserList(options = {}) {
	try {
		const {
			includeRoles = null,
			excludeRoles = null,
			includeTags = null,
			activeOnly = true,
			verifiedOnly = false,
			allowPatients = false,
			format = 'default',
			limit = 1000,
			sortBy = ['register_date'],
			decryptSensitiveInfo = true
		} = options;
		
		// 构建查询条件
		const where = {};
		
		// 激活状态过滤：只查询正常用户
		if (activeOnly) {
			where.status = 0;  // 0-正常，1-禁用，2-审核中，3-审核拒绝，4-已注销
		}
		
		// 查询所有用户
		let queryBuilder = db.collection('uni-id-users');
		
		// 添加查询条件
		if (Object.keys(where).length > 0) {
			queryBuilder = queryBuilder.where(where);
		}
		
		queryBuilder = queryBuilder
			.field({
				_id: true,
				username: true,
				nickname: true,
				avatar: true,  // 头像地址
				realname_auth: true,
				mobile: true,
				mobile_confirmed: true,  // 手机号认证状态
				email: true,  // 邮箱地址
				email_confirmed: true,  // 邮箱认证状态
				role: true,
				gender: true,  // 性别
				status: true,  // 用户状态：0 正常 1 禁用 2 审核中 3 审核拒绝 4 已注销
				tags: true,  // 用户标签
				register_date: true,  // 注册时间
				last_login_date: true,  // 最后登录时间
				comment: true  // 备注
			})
			.limit(limit);
		
		// 添加排序
		if (sortBy && sortBy.length > 0) {
			sortBy.forEach(field => {
				queryBuilder.orderBy(field, 'desc');
			});
		}
		
		const res = await queryBuilder.get();
		
		// 获取实际数据（兼容不同的返回格式）
		const userData = res.result?.data || res.data || [];
		
		if (!Array.isArray(userData)) {
			console.error('[getUserList] 查询结果格式错误:', res);
			return [];
		}
		
		// 过滤用户
		let filteredUsers = userData;
		
		// 角色过滤
		if (includeRoles || excludeRoles) {
			filteredUsers = filteredUsers.filter(user => 
				matchesRoleFilter(user, includeRoles, excludeRoles, allowPatients)
			);
		}
		
		// 实名认证过滤（扩展功能）
		if (verifiedOnly) {
			filteredUsers = filteredUsers.filter(user => 
				user.realname_auth && user.realname_auth.auth_status === 2
			);
		}
		
		// 标签过滤（扩展功能）
		if (includeTags && includeTags.length > 0) {
			filteredUsers = filteredUsers.filter(user => {
				if (!user.tags || !Array.isArray(user.tags)) return false;
				return includeTags.some(tag => user.tags.includes(tag));
			});
		}
		
		// 获取解密密钥（如果需要解密）
		const decryptSecret = decryptSensitiveInfo ? await getDecryptSecret() : '';
		if (decryptSensitiveInfo) {
			console.log('[getUserList] 解密密钥获取结果:', decryptSecret ? '密钥已获取' : '密钥为空');
		}
		
		// 格式化用户数据
		const formattedUsers = filteredUsers
			.map(user => formatUserData(user, format, allowPatients, decryptSecret))
			.filter(user => user !== null);  // 🔥 过滤掉返回 null 的用户（无有效角色）
		return formattedUsers;
		
	} catch (error) {
		console.error('[getUserList] 查询失败:', error);
		throw error;
	}
}

/**
 * 根据用户ID查询单个用户信息
 * 
 * @param {String} userId - 用户ID
 * @param {String} format - 格式化类型：'default', 'with_role', 'with_mobile', 'full'（默认 'default'）
 * @param {Boolean} allowPatients - 是否允许患者角色（默认 false）
 * @param {Boolean} decryptSensitiveInfo - 是否解密敏感信息（默认 true）
 * 
 * @returns {Promise<Object|null>} 格式化后的用户信息，未找到返回 null
 */
async function getUserById(userId, format = 'default', allowPatients = false, decryptSensitiveInfo = true) {
	try {
		if (!userId) {
			console.warn('[getUserById] 用户ID不能为空');
			return null;
		}
		
		const res = await db.collection('uni-id-users')
			.doc(userId)
			.field({
				_id: true,
				username: true,
				nickname: true,
				avatar: true,
				realname_auth: true,
				mobile: true,
				mobile_confirmed: true,
				email: true,
				email_confirmed: true,
				role: true,
				gender: true,
				status: true,
				tags: true,
				register_date: true,
				last_login_date: true,
				comment: true
			})
			.get();
		
		// 获取实际数据（兼容不同的返回格式）
		let rawUserData = res.result?.data || res.data;
		// 处理不同的返回格式：可能是对象或数组
		// 如果是数组，取第一个元素；如果是对象，直接使用
		const userData = Array.isArray(rawUserData) ? (rawUserData.length > 0 ? rawUserData[0] : null) : rawUserData;
		
		if (!userData) {
			console.warn(`[getUserById] 未找到用户: ${userId}`);
			return null;
		}
		
		// 检查角色权限
		if (!matchesRoleFilter(userData, null, null, allowPatients)) {
			console.warn(`[getUserById] 用户角色不在允许范围内: ${userId}`);
			return null;
		}
		
		// 获取解密密钥（如果需要解密）
		const decryptSecret = decryptSensitiveInfo ? await getDecryptSecret() : '';
		if (decryptSensitiveInfo) {
			console.log('[getUserById] 解密密钥获取结果:', decryptSecret ? '密钥已获取' : '密钥为空');
		}
		
		// 格式化用户数据
		return formatUserData(userData, format, allowPatients, decryptSecret);
		
	} catch (error) {
		console.error(`[getUserById] 查询失败 (${userId}):`, error);
		throw error;
	}
}

/**
 * 查询护士列表
 * 
 * @param {Object} options - 查询选项
 * @param {String} options.keyword - 搜索关键词
 * @param {String} options.format - 格式化类型：'default', 'with_role', 'with_mobile', 'full'（默认 'with_role'）
 * @param {Number} options.limit - 返回数量限制（默认 100）
 * 
 * @returns {Promise<Object>} { code, data, message }
 */
async function listNurses(options = {}) {
	try {
		const {
			keyword = '',
			format = 'with_role',
			limit = 100
		} = options;
		
		// 调用基础用户查询函数，筛选护士角色（包括护士和护士长）
		const nurses = await getUserList({
			includeRoles: ['nurse', 'head_nurse'],
			format,
			limit
		});
		
		// 根据关键词过滤
		const filteredNurses = filterUsersByKeyword(nurses, keyword);
		
		return {
			code: 200,
			data: filteredNurses,
			message: '查询成功'
		};
	} catch (error) {
		console.error('[listNurses] 查询失败:', error);
		return {
			code: 500,
			data: null,
			message: error.message || '查询护士列表失败'
		};
	}
}

/**
 * 根据用户ID查询护士信息
 * 
 * @param {String} userId - 用户ID
 * @param {String} format - 格式化类型：'default', 'with_role', 'with_mobile', 'full'（默认 'with_role'）
 * 
 * @returns {Promise<Object>} { code, data, message }
 */
async function getNurseById(userId, format = 'with_role') {
	try {
		if (!userId) {
			return {
				code: 400,
				data: null,
				message: '用户ID不能为空'
			};
		}
		
		// 调用基础用户查询函数，获取指定ID的护士
		// getUserById 已经通过 matchesRoleFilter 检查了角色（nurse 优先级 30 > 0，会通过检查）
		const nurse = await getUserById(userId, format);
		
		if (!nurse) {
			return {
				code: 404,
				data: null,
				message: '护士不存在'
			};
		}
		
		return {
			code: 200,
			data: nurse,
			message: '查询成功'
		};
	} catch (error) {
		console.error('[getNurseById] 查询失败:', error);
		return {
			code: 500,
			data: null,
			message: error.message || '查询护士信息失败'
		};
	}
}

/**
 * 查询医生列表
 * 
 * @param {Object} options - 查询选项
 * @param {String} options.keyword - 搜索关键词
 * @param {String} options.format - 格式化类型：'default', 'with_role', 'with_mobile', 'full'（默认 'with_role'）
 * @param {Number} options.limit - 返回数量限制（默认 100）
 * 
 * @returns {Promise<Object>} { code, data, message }
 */
async function listDoctors(options = {}) {
	try {
		const {
			keyword = '',
			format = 'with_role',
			limit = 100
		} = options;
		
		// 调用基础用户查询函数，筛选医生角色
		const doctors = await getUserList({
			includeRoles: ['doctor'],
			format,
			limit
		});
		
		// 根据关键词过滤
		const filteredDoctors = filterUsersByKeyword(doctors, keyword);
		
		return {
			code: 200,
			data: filteredDoctors,
			message: '查询成功'
		};
	} catch (error) {
		console.error('[listDoctors] 查询失败:', error);
		return {
			code: 500,
			data: null,
			message: error.message || '查询医生列表失败'
		};
	}
}

/**
 * 根据用户ID查询医生信息
 * 
 * @param {String} userId - 用户ID
 * @param {String} format - 格式化类型：'default', 'with_role', 'with_mobile', 'full'（默认 'with_role'）
 * 
 * @returns {Promise<Object>} { code, data, message }
 */
async function getDoctorById(userId, format = 'with_role') {
	try {
		if (!userId) {
			return {
				code: 400,
				data: null,
				message: '用户ID不能为空'
			};
		}
		
		// 调用基础用户查询函数，获取指定ID的医生
		// getUserById 已经通过 matchesRoleFilter 检查了角色（doctor 优先级 70 > 0，会通过检查）
		const doctor = await getUserById(userId, format);
		
		if (!doctor) {
			return {
				code: 404,
				data: null,
				message: '医生不存在'
			};
		}
		
		return {
			code: 200,
			data: doctor,
			message: '查询成功'
		};
	} catch (error) {
		console.error('[getDoctorById] 查询失败:', error);
		return {
			code: 500,
			data: null,
			message: error.message || '查询医生信息失败'
		};
	}
}

/**
 * 查询员工列表（排除医生、护士等专业角色）
 * 
 * @param {Object} options - 查询选项
 * @param {String} options.keyword - 搜索关键词
 * @param {String} options.format - 格式化类型：'default', 'with_role', 'with_mobile', 'full'（默认 'with_role'）
 * @param {Number} options.limit - 返回数量限制（默认 100）
 * 
 * @returns {Promise<Object>} { code, data, message }
 */
async function listStuffs(options = {}) {
	try {
		const {
			keyword = '',
			format = 'with_role',
			limit = 100
		} = options;
		
		// 调用基础用户查询函数，筛选员工角色，排除专业医疗角色
		const stuffs = await getUserList({
			includeRoles: ['staff', 'administrative', 'finance', 'purchaser'],
			format,
			limit
		});
		
		// 根据关键词过滤
		const filteredStuffs = filterUsersByKeyword(stuffs, keyword);
		
		return {
			code: 200,
			data: filteredStuffs,
			message: '查询成功'
		};
	} catch (error) {
		console.error('[listStuffs] 查询失败:', error);
		return {
			code: 500,
			data: null,
			message: error.message || '查询员工列表失败'
		};
	}
}

/**
 * 根据用户ID查询员工信息
 * 
 * @param {String} userId - 用户ID
 * @param {String} format - 格式化类型：'default', 'with_role', 'with_mobile', 'full'（默认 'with_role'）
 * 
 * @returns {Promise<Object>} { code, data, message }
 */
async function getStuffById(userId, format = 'with_role') {
	try {
		if (!userId) {
			return {
				code: 400,
				data: null,
				message: '用户ID不能为空'
			};
		}
		
		// 调用基础用户查询函数，获取指定ID的员工
		// getUserById 已经通过 matchesRoleFilter 检查了角色（staff等角色优先级 > 0，会通过检查）
		const stuff = await getUserById(userId, format);
		
		if (!stuff) {
			return {
				code: 404,
				data: null,
				message: '员工不存在'
			};
		}
		
		return {
			code: 200,
			data: stuff,
			message: '查询成功'
		};
	} catch (error) {
		console.error('[getStuffById] 查询失败:', error);
		return {
			code: 500,
			data: null,
			message: error.message || '查询员工信息失败'
		};
	}
}

/**
 * 查询患者列表
 * 
 * @param {Object} options - 查询选项
 * @param {String} options.keyword - 搜索关键词
 * @param {String} options.format - 格式化类型：'default', 'with_role', 'with_mobile', 'full'（默认 'with_role'）
 * @param {Number} options.limit - 返回数量限制（默认 100）
 * 
 * @returns {Promise<Object>} { code, data, message }
 */
async function listPatients(options = {}) {
	try {
		const {
			keyword = '',
			format = 'with_role',
			limit = 100
		} = options;
		
		// 调用基础用户查询函数，筛选患者角色
		const patients = await getUserList({
			includeRoles: ['patient'],
			format,
			limit,
			allowPatients: true  // 允许患者角色
		});
		
		// 根据关键词过滤
		const filteredPatients = filterUsersByKeyword(patients, keyword);
		
		return {
			code: 200,
			data: filteredPatients,
			message: '查询成功'
		};
	} catch (error) {
		console.error('[listPatients] 查询失败:', error);
		return {
			code: 500,
			data: null,
			message: error.message || '查询患者列表失败'
		};
	}
}

/**
 * 根据用户ID查询患者信息
 * 
 * @param {String} userId - 用户ID
 * @param {String} format - 格式化类型：'default', 'with_role', 'with_mobile', 'full'（默认 'with_role'）
 * 
 * @returns {Promise<Object>} { code, data, message }
 */
async function getPatientById(userId, format = 'with_role') {
	try {
		if (!userId) {
			return {
				code: 400,
				data: null,
				message: '用户ID不能为空'
			};
		}
		
		// 调用基础用户查询函数，获取指定ID的患者
		// getUserById 已经通过 matchesRoleFilter 检查了角色（allowPatients=true 时，patient 角色会通过检查）
		const patient = await getUserById(userId, format, true); // 允许患者角色
		
		if (!patient) {
			return {
				code: 404,
				data: null,
				message: '患者不存在'
			};
		}
		
		return {
			code: 200,
			data: patient,
			message: '查询成功'
		};
	} catch (error) {
		console.error('[getPatientById] 查询失败:', error);
		return {
			code: 500,
			data: null,
			message: error.message || '查询患者信息失败'
		};
	}
}

// 导出函数
module.exports = {
	getUserList,
	getUserById,
	extractDisplayName,
	getMainRole,
	getRoleText,
	formatUserData,
	listDoctors,
	getDoctorById,
	listNurses,
	getNurseById,
	listStuffs,
	getStuffById,
	listPatients,
	getPatientById,
	getDecryptSecret,
	decryptRealnameAuth,
	ROLE_TEXT_MAP,
	ROLE_PRIORITY
};

